var carouse = function ($) {
  if (typeof Object.create !== 'function') {
    Object.create = function (obj) {
      function F () {
      }

      F.prototype = obj
      return new F()
    }
  }
  var Carousel = {
    init: function (options, el) {
      var base = this

      base.$elem = $(el)
      base.options = $.extend({}, $.fn.owlCarousel.options, base.$elem.data(), options)

      base.userOptions = options
      base.loadContent()
    },

    loadContent: function () {
      var base = this, url

      function getData (data) {
        var i, content = ''
        if (typeof base.options.jsonSuccess === 'function') {
          base.options.jsonSuccess.apply(this, [data])
        } else {
          for (i in data.owl) {
            if (data.owl.hasOwnProperty(i)) {
              content += data.owl[i].item
            }
          }
          base.$elem.html(content)
        }
        base.logIn()
      }

      if (typeof base.options.beforeInit === 'function') {
        base.options.beforeInit.apply(this, [base.$elem])
      }

      if (typeof base.options.jsonPath === 'string') {
        url = base.options.jsonPath
        $.getJSON(url, getData)
      } else {
        base.logIn()
      }
    },

    logIn: function () {
      var base = this

      base.$elem.data({
        'owl-originalStyles': base.$elem.attr('style'),
        'owl-originalClasses': base.$elem.attr('class')
      })

      base.$elem.css({opacity: 0})
      base.orignalItems = base.options.items
      base.checkBrowser()
      base.wrapperWidth = 0
      base.checkVisible = null
      base.setVars()
    },

    setVars: function () {
      var base = this
      if (base.$elem.children().length === 0) {
        return false
      }
      base.baseClass()
      base.eventTypes()
      base.$userItems = base.$elem.children()
      base.itemsAmount = base.$userItems.length
      base.wrapItems()
      base.$owlItems = base.$elem.find('.owl-item')
      base.$owlWrapper = base.$elem.find('.owl-wrapper')
      base.playDirection = 'next'
      base.prevItem = 0
      base.prevArr = [0]
      base.currentItem = 0
      base.customEvents()
      base.onStartup()
    },

    onStartup: function () {
      var base = this
      base.updateItems()
      base.calculateAll()
      base.buildControls()
      base.updateControls()
      base.response()
      base.moveEvents()
      base.stopOnHover()
      base.owlStatus()

      if (base.options.transitionStyle !== false) {
        base.transitionTypes(base.options.transitionStyle)
      }
      if (base.options.autoPlay === true) {
        base.options.autoPlay = 5000
      }
      base.play()

      base.$elem.find('.owl-wrapper').css('display', 'block')

      if (!base.$elem.is(':visible')) {
        base.watchVisibility()
      } else {
        base.$elem.css('opacity', 1)
      }
      base.onstartup = false
      base.eachMoveUpdate()
      if (typeof base.options.afterInit === 'function') {
        base.options.afterInit.apply(this, [base.$elem])
      }
    },

    eachMoveUpdate: function () {
      var base = this

      if (base.options.lazyLoad === true) {
        base.lazyLoad()
      }
      if (base.options.autoHeight === true) {
        base.autoHeight()
      }
      base.onVisibleItems()

      if (typeof base.options.afterAction === 'function') {
        base.options.afterAction.apply(this, [base.$elem])
      }
    },

    updateVars: function () {
      var base = this
      if (typeof base.options.beforeUpdate === 'function') {
        base.options.beforeUpdate.apply(this, [base.$elem])
      }
      base.watchVisibility()
      base.updateItems()
      base.calculateAll()
      base.updatePosition()
      base.updateControls()
      base.eachMoveUpdate()
      if (typeof base.options.afterUpdate === 'function') {
        base.options.afterUpdate.apply(this, [base.$elem])
      }
    },

    reload: function () {
      var base = this
      window.setTimeout(function () {
        base.updateVars()
      }, 0)
    },

    watchVisibility: function () {
      var base = this

      if (base.$elem.is(':visible') === false) {
        base.$elem.css({opacity: 0})
        window.clearInterval(base.autoPlayInterval)
        window.clearInterval(base.checkVisible)
      } else {
        return false
      }
      base.checkVisible = window.setInterval(function () {
        if (base.$elem.is(':visible')) {
          base.reload()
          base.$elem.animate({opacity: 1}, 200)
          window.clearInterval(base.checkVisible)
        }
      }, 500)
    },

    wrapItems: function () {
      var base = this
      base.$userItems.wrapAll('<div class="owl-wrapper">').wrap('<div class="owl-item"></div>')
      base.$elem.find('.owl-wrapper').wrap('<div class="owl-wrapper-outer">')
      base.wrapperOuter = base.$elem.find('.owl-wrapper-outer')
      base.$elem.css('display', 'block')
    },

    baseClass: function () {
      var base = this,
        hasBaseClass = base.$elem.hasClass(base.options.baseClass),
        hasThemeClass = base.$elem.hasClass(base.options.theme)

      if (!hasBaseClass) {
        base.$elem.addClass(base.options.baseClass)
      }

      if (!hasThemeClass) {
        base.$elem.addClass(base.options.theme)
      }
    },

    updateItems: function () {
      var base = this, width, i

      if (base.options.responsive === false) {
        return false
      }
      if (base.options.singleItem === true) {
        base.options.items = base.orignalItems = 1
        base.options.itemsCustom = false
        base.options.itemsDesktop = false
        base.options.itemsDesktopSmall = false
        base.options.itemsTablet = false
        base.options.itemsTabletSmall = false
        base.options.itemsMobile = false
        return false
      }

      width = $(base.options.responsiveBaseWidth).width()

      if (width > (base.options.itemsDesktop[0] || base.orignalItems)) {
        base.options.items = base.orignalItems
      }
      if (base.options.itemsCustom !== false) {
        // Reorder array by screen size
        base.options.itemsCustom.sort(function (a, b) {
          return a[0] - b[0]
        })

        for (i = 0; i < base.options.itemsCustom.length; i += 1) {
          if (base.options.itemsCustom[i][0] <= width) {
            base.options.items = base.options.itemsCustom[i][1]
          }
        }
      } else {
        if (width <= base.options.itemsDesktop[0] && base.options.itemsDesktop !== false) {
          base.options.items = base.options.itemsDesktop[1]
        }

        if (width <= base.options.itemsDesktopSmall[0] && base.options.itemsDesktopSmall !== false) {
          base.options.items = base.options.itemsDesktopSmall[1]
        }

        if (width <= base.options.itemsTablet[0] && base.options.itemsTablet !== false) {
          base.options.items = base.options.itemsTablet[1]
        }

        if (width <= base.options.itemsTabletSmall[0] && base.options.itemsTabletSmall !== false) {
          base.options.items = base.options.itemsTabletSmall[1]
        }

        if (width <= base.options.itemsMobile[0] && base.options.itemsMobile !== false) {
          base.options.items = base.options.itemsMobile[1]
        }
      }

      // if number of items is less than declared
      if (base.options.items > base.itemsAmount && base.options.itemsScaleUp === true) {
        base.options.items = base.itemsAmount
      }
    },

    response: function () {
      var base = this,
        smallDelay,
        lastWindowWidth

      if (base.options.responsive !== true) {
        return false
      }
      lastWindowWidth = $(window).width()

      base.resizer = function () {
        if ($(window).width() !== lastWindowWidth) {
          if (base.options.autoPlay !== false) {
            window.clearInterval(base.autoPlayInterval)
          }
          window.clearTimeout(smallDelay)
          smallDelay = window.setTimeout(function () {
            lastWindowWidth = $(window).width()
            base.updateVars()
          }, base.options.responsiveRefreshRate)
        }
      }
      $(window).resize(base.resizer)
    },

    updatePosition: function () {
      var base = this
      base.jumpTo(base.currentItem)
      if (base.options.autoPlay !== false) {
        base.checkAp()
      }
    },

    appendItemsSizes: function () {
      var base = this,
        roundPages = 0,
        lastItem = base.itemsAmount - base.options.items

      base.$owlItems.each(function (index) {
        var $this = $(this)
        $this
          .css({'width': base.itemWidth})
          .data('owl-item', Number(index))

        if (index % base.options.items === 0 || index === lastItem) {
          if (!(index > lastItem)) {
            roundPages += 1
          }
        }
        $this.data('owl-roundPages', roundPages)
      })
    },

    appendWrapperSizes: function () {
      var base = this,
        width = base.$owlItems.length * base.itemWidth

      base.$owlWrapper.css({
        'width': width * 2,
        'left': 0
      })
      base.appendItemsSizes()
    },

    calculateAll: function () {
      var base = this
      base.calculateWidth()
      base.appendWrapperSizes()
      base.loops()
      base.max()
    },

    calculateWidth: function () {
      var base = this
      base.itemWidth = Math.round(base.$elem.width() / base.options.items)
    },

    max: function () {
      var base = this,
        maximum = ((base.itemsAmount * base.itemWidth) - base.options.items * base.itemWidth) * -1
      if (base.options.items > base.itemsAmount) {
        base.maximumItem = 0
        maximum = 0
        base.maximumPixels = 0
      } else {
        base.maximumItem = base.itemsAmount - base.options.items
        base.maximumPixels = maximum
      }
      return maximum
    },

    min: function () {
      return 0
    },

    loops: function () {
      var base = this,
        prev = 0,
        elWidth = 0,
        i,
        item,
        roundPageNum

      base.positionsInArray = [0]
      base.pagesInArray = []

      for (i = 0; i < base.itemsAmount; i += 1) {
        elWidth += base.itemWidth
        base.positionsInArray.push(-elWidth)

        if (base.options.scrollPerPage === true) {
          item = $(base.$owlItems[i])
          roundPageNum = item.data('owl-roundPages')
          if (roundPageNum !== prev) {
            base.pagesInArray[prev] = base.positionsInArray[i]
            prev = roundPageNum
          }
        }
      }
    },

    buildControls: function () {
      var base = this
      if (base.options.navigation === true || base.options.pagination === true) {
        base.owlControls = $('<div class="owl-controls"/>').toggleClass('clickable', !base.browser.isTouch).appendTo(base.$elem)
      }
      if (base.options.pagination === true) {
        base.buildPagination()
      }
      if (base.options.navigation === true) {
        base.buildButtons()
      }
    },

    buildButtons: function () {
      var base = this,
        buttonsWrapper = $('<div class="owl-buttons"/>')
      base.owlControls.append(buttonsWrapper)

      base.buttonPrev = $('<div/>', {
        'class': 'owl-prev',
        'html': base.options.navigationText[0] || ''
      })

      base.buttonNext = $('<div/>', {
        'class': 'owl-next',
        'html': base.options.navigationText[1] || ''
      })

      buttonsWrapper
        .append(base.buttonPrev)
        .append(base.buttonNext)

      buttonsWrapper.on('touchstart.owlControls mousedown.owlControls', 'div[class^="owl"]', function (event) {
        event.preventDefault()
      })

      buttonsWrapper.on('touchend.owlControls mouseup.owlControls', 'div[class^="owl"]', function (event) {
        event.preventDefault()
        if ($(this).hasClass('owl-next')) {
          base.next()
        } else {
          base.prev()
        }
      })
    },

    buildPagination: function () {
      var base = this

      base.paginationWrapper = $('<div class="owl-pagination"/>')
      base.owlControls.append(base.paginationWrapper)

      base.paginationWrapper.on('touchend.owlControls mouseup.owlControls', '.owl-page', function (event) {
        event.preventDefault()
        if (Number($(this).data('owl-page')) !== base.currentItem) {
          base.goTo(Number($(this).data('owl-page')), true)
        }
      })
    },

    updatePagination: function () {
      var base = this,
        counter,
        lastPage,
        lastItem,
        i,
        paginationButton,
        paginationButtonInner

      if (base.options.pagination === false) {
        return false
      }

      base.paginationWrapper.html('')

      counter = 0
      lastPage = base.itemsAmount - base.itemsAmount % base.options.items

      for (i = 0; i < base.itemsAmount; i += 1) {
        if (i % base.options.items === 0) {
          counter += 1
          if (lastPage === i) {
            lastItem = base.itemsAmount - base.options.items
          }
          paginationButton = $('<div/>', {
            'class': 'owl-page'
          })
          paginationButtonInner = $('<span></span>', {
            'text': base.options.paginationNumbers === true ? counter : '',
            'class': base.options.paginationNumbers === true ? 'owl-numbers' : ''
          })
          paginationButton.append(paginationButtonInner)

          paginationButton.data('owl-page', lastPage === i ? lastItem : i)
          paginationButton.data('owl-roundPages', counter)

          base.paginationWrapper.append(paginationButton)
        }
      }
      base.checkPagination()
    },
    checkPagination: function () {
      var base = this
      if (base.options.pagination === false) {
        return false
      }
      base.paginationWrapper.find('.owl-page').each(function () {
        if ($(this).data('owl-roundPages') === $(base.$owlItems[base.currentItem]).data('owl-roundPages')) {
          base.paginationWrapper
            .find('.owl-page')
            .removeClass('active')
          $(this).addClass('active')
        }
      })
    },

    checkNavigation: function () {
      var base = this

      if (base.options.navigation === false) {
        return false
      }
      if (base.options.rewindNav === false) {
        if (base.currentItem === 0 && base.maximumItem === 0) {
          base.buttonPrev.addClass('disabled')
          base.buttonNext.addClass('disabled')
        } else if (base.currentItem === 0 && base.maximumItem !== 0) {
          base.buttonPrev.addClass('disabled')
          base.buttonNext.removeClass('disabled')
        } else if (base.currentItem === base.maximumItem) {
          base.buttonPrev.removeClass('disabled')
          base.buttonNext.addClass('disabled')
        } else if (base.currentItem !== 0 && base.currentItem !== base.maximumItem) {
          base.buttonPrev.removeClass('disabled')
          base.buttonNext.removeClass('disabled')
        }
      }
    },

    updateControls: function () {
      var base = this
      base.updatePagination()
      base.checkNavigation()
      if (base.owlControls) {
        if (base.options.items >= base.itemsAmount) {
          base.owlControls.hide()
        } else {
          base.owlControls.show()
        }
      }
    },

    destroyControls: function () {
      var base = this
      if (base.owlControls) {
        base.owlControls.remove()
      }
    },

    next: function (speed) {
      var base = this

      if (base.isTransition) {
        return false
      }

      base.currentItem += base.options.scrollPerPage === true ? base.options.items : 1
      if (base.currentItem > base.maximumItem + (base.options.scrollPerPage === true ? (base.options.items - 1) : 0)) {
        if (base.options.rewindNav === true) {
          base.currentItem = 0
          speed = 'rewind'
        } else {
          base.currentItem = base.maximumItem
          return false
        }
      }
      base.goTo(base.currentItem, speed)
    },

    prev: function (speed) {
      var base = this

      if (base.isTransition) {
        return false
      }

      if (base.options.scrollPerPage === true && base.currentItem > 0 && base.currentItem < base.options.items) {
        base.currentItem = 0
      } else {
        base.currentItem -= base.options.scrollPerPage === true ? base.options.items : 1
      }
      if (base.currentItem < 0) {
        if (base.options.rewindNav === true) {
          base.currentItem = base.maximumItem
          speed = 'rewind'
        } else {
          base.currentItem = 0
          return false
        }
      }
      base.goTo(base.currentItem, speed)
    },

    goTo: function (position, speed, drag) {
      var base = this,
        goToPixel

      if (base.isTransition) {
        return false
      }
      if (typeof base.options.beforeMove === 'function') {
        base.options.beforeMove.apply(this, [base.$elem])
      }
      if (position >= base.maximumItem) {
        position = base.maximumItem
      } else if (position <= 0) {
        position = 0
      }

      base.currentItem = base.owl.currentItem = position
      if (base.options.transitionStyle !== false && drag !== 'drag' && base.options.items === 1 && base.browser.support3d === true) {
        base.swapSpeed(0)
        if (base.browser.support3d === true) {
          base.transition3d(base.positionsInArray[position])
        } else {
          base.css2slide(base.positionsInArray[position], 1)
        }
        base.afterGo()
        base.singleItemTransition()
        return false
      }
      goToPixel = base.positionsInArray[position]

      if (base.browser.support3d === true) {
        base.isCss3Finish = false

        if (speed === true) {
          base.swapSpeed('paginationSpeed')
          window.setTimeout(function () {
            base.isCss3Finish = true
          }, base.options.paginationSpeed)
        } else if (speed === 'rewind') {
          base.swapSpeed(base.options.rewindSpeed)
          window.setTimeout(function () {
            base.isCss3Finish = true
          }, base.options.rewindSpeed)
        } else {
          base.swapSpeed('slideSpeed')
          window.setTimeout(function () {
            base.isCss3Finish = true
          }, base.options.slideSpeed)
        }
        base.transition3d(goToPixel)
      } else {
        if (speed === true) {
          base.css2slide(goToPixel, base.options.paginationSpeed)
        } else if (speed === 'rewind') {
          base.css2slide(goToPixel, base.options.rewindSpeed)
        } else {
          base.css2slide(goToPixel, base.options.slideSpeed)
        }
      }
      base.afterGo()
    },

    jumpTo: function (position) {
      var base = this
      if (typeof base.options.beforeMove === 'function') {
        base.options.beforeMove.apply(this, [base.$elem])
      }
      if (position >= base.maximumItem || position === -1) {
        position = base.maximumItem
      } else if (position <= 0) {
        position = 0
      }
      base.swapSpeed(0)
      if (base.browser.support3d === true) {
        base.transition3d(base.positionsInArray[position])
      } else {
        base.css2slide(base.positionsInArray[position], 1)
      }
      base.currentItem = base.owl.currentItem = position
      base.afterGo()
    },

    afterGo: function () {
      var base = this

      base.prevArr.push(base.currentItem)
      base.prevItem = base.owl.prevItem = base.prevArr[base.prevArr.length - 2]
      base.prevArr.shift(0)

      if (base.prevItem !== base.currentItem) {
        base.checkPagination()
        base.checkNavigation()
        base.eachMoveUpdate()

        if (base.options.autoPlay !== false) {
          base.checkAp()
        }
      }
      if (typeof base.options.afterMove === 'function' && base.prevItem !== base.currentItem) {
        base.options.afterMove.apply(this, [base.$elem])
      }
    },

    stop: function () {
      var base = this
      base.apStatus = 'stop'
      window.clearInterval(base.autoPlayInterval)
    },

    checkAp: function () {
      var base = this
      if (base.apStatus !== 'stop') {
        base.play()
      }
    },

    play: function () {
      var base = this
      base.apStatus = 'play'
      if (base.options.autoPlay === false) {
        return false
      }
      window.clearInterval(base.autoPlayInterval)
      base.autoPlayInterval = window.setInterval(function () {
        base.next(true)
      }, base.options.autoPlay)
    },

    swapSpeed: function (action) {
      var base = this
      if (action === 'slideSpeed') {
        base.$owlWrapper.css(base.addCssSpeed(base.options.slideSpeed))
      } else if (action === 'paginationSpeed') {
        base.$owlWrapper.css(base.addCssSpeed(base.options.paginationSpeed))
      } else if (typeof action !== 'string') {
        base.$owlWrapper.css(base.addCssSpeed(action))
      }
    },

    addCssSpeed: function (speed) {
      return {
        '-webkit-transition': 'all ' + speed + 'ms ease',
        '-moz-transition': 'all ' + speed + 'ms ease',
        '-o-transition': 'all ' + speed + 'ms ease',
        'transition': 'all ' + speed + 'ms ease'
      }
    },

    removeTransition: function () {
      return {
        '-webkit-transition': '',
        '-moz-transition': '',
        '-o-transition': '',
        'transition': ''
      }
    },

    doTranslate: function (pixels) {
      return {
        '-webkit-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-moz-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-o-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-ms-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        'transform': 'translate3d(' + pixels + 'px, 0px,0px)'
      }
    },

    transition3d: function (value) {
      var base = this
      base.$owlWrapper.css(base.doTranslate(value))
    },

    css2move: function (value) {
      var base = this
      base.$owlWrapper.css({'left': value})
    },

    css2slide: function (value, speed) {
      var base = this

      base.isCssFinish = false
      base.$owlWrapper.stop(true, true).animate({
        'left': value
      }, {
        duration: speed || base.options.slideSpeed,
        complete: function () {
          base.isCssFinish = true
        }
      })
    },

    checkBrowser: function () {
      var base = this,
        translate3D = 'translate3d(0px, 0px, 0px)',
        tempElem = document.createElement('div'),
        regex,
        asSupport,
        support3d,
        isTouch

      tempElem.style.cssText = '  -moz-transform:' + translate3D +
        '; -ms-transform:' + translate3D +
        '; -o-transform:' + translate3D +
        '; -webkit-transform:' + translate3D +
        '; transform:' + translate3D
      regex = /translate3d\(0px, 0px, 0px\)/g
      asSupport = tempElem.style.cssText.match(regex)
      support3d = (asSupport !== null && asSupport.length === 1)

      isTouch = 'ontouchstart' in window || window.navigator.msMaxTouchPoints

      base.browser = {
        'support3d': support3d,
        'isTouch': isTouch
      }
    },

    moveEvents: function () {
      var base = this
      if (base.options.mouseDrag !== false || base.options.touchDrag !== false) {
        base.gestures()
        base.disabledEvents()
      }
    },

    eventTypes: function () {
      var base = this,
        types = ['s', 'e', 'x']

      base.ev_types = {}

      if (base.options.mouseDrag === true && base.options.touchDrag === true) {
        types = [
          'touchstart.owl mousedown.owl',
          'touchmove.owl mousemove.owl',
          'touchend.owl touchcancel.owl mouseup.owl'
        ]
      } else if (base.options.mouseDrag === false && base.options.touchDrag === true) {
        types = [
          'touchstart.owl',
          'touchmove.owl',
          'touchend.owl touchcancel.owl'
        ]
      } else if (base.options.mouseDrag === true && base.options.touchDrag === false) {
        types = [
          'mousedown.owl',
          'mousemove.owl',
          'mouseup.owl'
        ]
      }

      base.ev_types.start = types[0]
      base.ev_types.move = types[1]
      base.ev_types.end = types[2]
    },

    disabledEvents: function () {
      var base = this
      base.$elem.on('dragstart.owl', function (event) {
        event.preventDefault()
      })
      base.$elem.on('mousedown.disableTextSelect', function (e) {
        return $(e.target).is('input, textarea, select, option')
      })
    },

    gestures: function () {
      /* jslint unparam: true */
      var base = this,
        locals = {
          offsetX: 0,
          offsetY: 0,
          baseElWidth: 0,
          relativePos: 0,
          position: null,
          minSwipe: null,
          maxSwipe: null,
          sliding: null,
          dargging: null,
          targetElement: null
        }

      base.isCssFinish = true

      function getTouches (event) {
        if (event.touches !== undefined) {
          return {
            x: event.touches[0].pageX,
            y: event.touches[0].pageY
          }
        }

        if (event.touches === undefined) {
          if (event.pageX !== undefined) {
            return {
              x: event.pageX,
              y: event.pageY
            }
          }
          if (event.pageX === undefined) {
            return {
              x: event.clientX,
              y: event.clientY
            }
          }
        }
      }

      function swapEvents (type) {
        if (type === 'on') {
          $(document).on(base.ev_types.move, dragMove)
          $(document).on(base.ev_types.end, dragEnd)
        } else if (type === 'off') {
          $(document).off(base.ev_types.move)
          $(document).off(base.ev_types.end)
        }
      }

      function dragStart (event) {
        var ev = event.originalEvent || event || window.event,
          position

        if (ev.which === 3) {
          return false
        }
        if (base.itemsAmount <= base.options.items) {
          return
        }
        if (base.isCssFinish === false && !base.options.dragBeforeAnimFinish) {
          return false
        }
        if (base.isCss3Finish === false && !base.options.dragBeforeAnimFinish) {
          return false
        }

        if (base.options.autoPlay !== false) {
          window.clearInterval(base.autoPlayInterval)
        }

        if (base.browser.isTouch !== true && !base.$owlWrapper.hasClass('grabbing')) {
          base.$owlWrapper.addClass('grabbing')
        }

        base.newPosX = 0
        base.newRelativeX = 0

        $(this).css(base.removeTransition())

        position = $(this).position()
        locals.relativePos = position.left

        locals.offsetX = getTouches(ev).x - position.left
        locals.offsetY = getTouches(ev).y - position.top

        swapEvents('on')

        locals.sliding = false
        locals.targetElement = ev.target || ev.srcElement
      }

      function dragMove (event) {
        var ev = event.originalEvent || event || window.event,
          minSwipe,
          maxSwipe

        base.newPosX = getTouches(ev).x - locals.offsetX
        base.newPosY = getTouches(ev).y - locals.offsetY
        base.newRelativeX = base.newPosX - locals.relativePos

        if (typeof base.options.startDragging === 'function' && locals.dragging !== true && base.newRelativeX !== 0) {
          locals.dragging = true
          base.options.startDragging.apply(base, [base.$elem])
        }

        if ((base.newRelativeX > 8 || base.newRelativeX < -8) && (base.browser.isTouch === true)) {
          if (ev.preventDefault !== undefined) {
            ev.preventDefault()
          } else {
            ev.returnValue = false
          }
          locals.sliding = true
        }

        if ((base.newPosY > 10 || base.newPosY < -10) && locals.sliding === false) {
          $(document).off('touchmove.owl')
        }

        minSwipe = function () {
          return base.newRelativeX / 5
        }

        maxSwipe = function () {
          return base.maximumPixels + base.newRelativeX / 5
        }

        base.newPosX = Math.max(Math.min(base.newPosX, minSwipe()), maxSwipe())
        if (base.browser.support3d === true) {
          base.transition3d(base.newPosX)
        } else {
          base.css2move(base.newPosX)
        }
      }

      function dragEnd (event) {
        var ev = event.originalEvent || event || window.event,
          newPosition,
          handlers,
          owlStopEvent

        ev.target = ev.target || ev.srcElement

        locals.dragging = false

        if (base.browser.isTouch !== true) {
          base.$owlWrapper.removeClass('grabbing')
        }

        if (base.newRelativeX < 0) {
          base.dragDirection = base.owl.dragDirection = 'left'
        } else {
          base.dragDirection = base.owl.dragDirection = 'right'
        }

        if (base.newRelativeX !== 0) {
          newPosition = base.getNewPosition()
          base.goTo(newPosition, false, 'drag')
          if (locals.targetElement === ev.target && base.browser.isTouch !== true) {
            $(ev.target).on('click.disable', function (ev) {
              ev.stopImmediatePropagation()
              ev.stopPropagation()
              ev.preventDefault()
              $(ev.target).off('click.disable')
            })
            handlers = $._data(ev.target, 'events').click
            owlStopEvent = handlers.pop()
            handlers.splice(0, 0, owlStopEvent)
          }
        }
        swapEvents('off')
      }

      base.$elem.on(base.ev_types.start, '.owl-wrapper', dragStart)
    },

    getNewPosition: function () {
      var base = this,
        newPosition = base.closestItem()

      if (newPosition > base.maximumItem) {
        base.currentItem = base.maximumItem
        newPosition = base.maximumItem
      } else if (base.newPosX >= 0) {
        newPosition = 0
        base.currentItem = 0
      }
      return newPosition
    },
    closestItem: function () {
      var base = this,
        array = base.options.scrollPerPage === true ? base.pagesInArray : base.positionsInArray,
        goal = base.newPosX,
        closest = null

      $.each(array, function (i, v) {
        if (goal - (base.itemWidth / 20) > array[i + 1] && goal - (base.itemWidth / 20) < v && base.moveDirection() === 'left') {
          closest = v
          if (base.options.scrollPerPage === true) {
            base.currentItem = $.inArray(closest, base.positionsInArray)
          } else {
            base.currentItem = i
          }
        } else if (goal + (base.itemWidth / 20) < v && goal + (base.itemWidth / 20) > (array[i + 1] || array[i] - base.itemWidth) && base.moveDirection() === 'right') {
          if (base.options.scrollPerPage === true) {
            closest = array[i + 1] || array[array.length - 1]
            base.currentItem = $.inArray(closest, base.positionsInArray)
          } else {
            closest = array[i + 1]
            base.currentItem = i + 1
          }
        }
      })
      return base.currentItem
    },

    moveDirection: function () {
      var base = this,
        direction
      if (base.newRelativeX < 0) {
        direction = 'right'
        base.playDirection = 'next'
      } else {
        direction = 'left'
        base.playDirection = 'prev'
      }
      return direction
    },

    customEvents: function () {
      /* jslint unparam: true */
      var base = this
      base.$elem.on('owl.next', function () {
        base.next()
      })
      base.$elem.on('owl.prev', function () {
        base.prev()
      })
      base.$elem.on('owl.play', function (event, speed) {
        base.options.autoPlay = speed
        base.play()
        base.hoverStatus = 'play'
      })
      base.$elem.on('owl.stop', function () {
        base.stop()
        base.hoverStatus = 'stop'
      })
      base.$elem.on('owl.goTo', function (event, item) {
        base.goTo(item)
      })
      base.$elem.on('owl.jumpTo', function (event, item) {
        base.jumpTo(item)
      })
    },

    stopOnHover: function () {
      var base = this
      if (base.options.stopOnHover === true && base.browser.isTouch !== true && base.options.autoPlay !== false) {
        base.$elem.on('mouseover', function () {
          base.stop()
        })
        base.$elem.on('mouseout', function () {
          if (base.hoverStatus !== 'stop') {
            base.play()
          }
        })
      }
    },

    lazyLoad: function () {
      var base = this,
        i,
        $item,
        itemNumber,
        $lazyImg,
        follow

      if (base.options.lazyLoad === false) {
        return false
      }
      for (i = 0; i < base.itemsAmount; i += 1) {
        $item = $(base.$owlItems[i])

        if ($item.data('owl-loaded') === 'loaded') {
          continue
        }

        itemNumber = $item.data('owl-item')
        $lazyImg = $item.find('.lazyOwl')

        if (typeof $lazyImg.data('src') !== 'string') {
          $item.data('owl-loaded', 'loaded')
          continue
        }
        if ($item.data('owl-loaded') === undefined) {
          $lazyImg.hide()
          $item.addClass('loading').data('owl-loaded', 'checked')
        }
        if (base.options.lazyFollow === true) {
          follow = itemNumber >= base.currentItem
        } else {
          follow = true
        }
        if (follow && itemNumber < base.currentItem + base.options.items && $lazyImg.length) {
          $lazyImg.each(function () {
            base.lazyPreload($item, $(this))
          })
        }
      }
    },

    lazyPreload: function ($item, $lazyImg) {
      var base = this,
        iterations = 0,
        isBackgroundImg

      if ($lazyImg.prop('tagName') === 'DIV') {
        $lazyImg.css('background-image', 'url(' + $lazyImg.data('src') + ')')
        isBackgroundImg = true
      } else {
        $lazyImg[0].src = $lazyImg.data('src')
      }

      function showImage () {
        $item.data('owl-loaded', 'loaded').removeClass('loading')
        $lazyImg.removeAttr('data-src')
        if (base.options.lazyEffect === 'fade') {
          $lazyImg.fadeIn(400)
        } else {
          $lazyImg.show()
        }
        if (typeof base.options.afterLazyLoad === 'function') {
          base.options.afterLazyLoad.apply(this, [base.$elem])
        }
      }

      function checkLazyImage () {
        iterations += 1
        if (base.completeImg($lazyImg.get(0)) || isBackgroundImg === true) {
          showImage()
        } else if (iterations <= 100) { // if image loads in less than 10 seconds
          window.setTimeout(checkLazyImage, 100)
        } else {
          showImage()
        }
      }

      checkLazyImage()
    },

    autoHeight: function () {
      var base = this,
        $currentimg = $(base.$owlItems[base.currentItem]).find('img'),
        iterations

      function addHeight () {
        var $currentItem = $(base.$owlItems[base.currentItem]).height()
        base.wrapperOuter.css('height', $currentItem + 'px')
        if (!base.wrapperOuter.hasClass('autoHeight')) {
          window.setTimeout(function () {
            base.wrapperOuter.addClass('autoHeight')
          }, 0)
        }
      }

      function checkImage () {
        iterations += 1
        if (base.completeImg($currentimg.get(0))) {
          addHeight()
        } else if (iterations <= 100) { // if image loads in less than 10 seconds
          window.setTimeout(checkImage, 100)
        } else {
          base.wrapperOuter.css('height', '') // Else remove height attribute
        }
      }

      if ($currentimg.get(0) !== undefined) {
        iterations = 0
        checkImage()
      } else {
        addHeight()
      }
    },

    completeImg: function (img) {
      var naturalWidthType

      if (!img.complete) {
        return false
      }
      naturalWidthType = typeof img.naturalWidth
      if (naturalWidthType !== 'undefined' && img.naturalWidth === 0) {
        return false
      }
      return true
    },

    onVisibleItems: function () {
      var base = this,
        i

      if (base.options.addClassActive === true) {
        base.$owlItems.removeClass('active')
      }
      base.visibleItems = []
      for (i = base.currentItem; i < base.currentItem + base.options.items; i += 1) {
        base.visibleItems.push(i)

        if (base.options.addClassActive === true) {
          $(base.$owlItems[i]).addClass('active')
        }
      }
      base.owl.visibleItems = base.visibleItems
    },

    transitionTypes: function (className) {
      var base = this
      // Currently available: "fade", "backSlide", "goDown", "fadeUp"
      base.outClass = 'owl-' + className + '-out'
      base.inClass = 'owl-' + className + '-in'
    },

    singleItemTransition: function () {
      var base = this,
        outClass = base.outClass,
        inClass = base.inClass,
        $currentItem = base.$owlItems.eq(base.currentItem),
        $prevItem = base.$owlItems.eq(base.prevItem),
        prevPos = Math.abs(base.positionsInArray[base.currentItem]) + base.positionsInArray[base.prevItem],
        origin = Math.abs(base.positionsInArray[base.currentItem]) + base.itemWidth / 2,
        animEnd = 'webkitAnimationEnd oAnimationEnd MSAnimationEnd animationend'

      base.isTransition = true

      base.$owlWrapper
        .addClass('owl-origin')
        .css({
          '-webkit-transform-origin': origin + 'px',
          '-moz-perspective-origin': origin + 'px',
          'perspective-origin': origin + 'px'
        })

      function transStyles (prevPos) {
        return {
          'position': 'relative',
          'left': prevPos + 'px'
        }
      }

      $prevItem
        .css(transStyles(prevPos, 10))
        .addClass(outClass)
        .on(animEnd, function () {
          base.endPrev = true
          $prevItem.off(animEnd)
          base.clearTransStyle($prevItem, outClass)
        })

      $currentItem
        .addClass(inClass)
        .on(animEnd, function () {
          base.endCurrent = true
          $currentItem.off(animEnd)
          base.clearTransStyle($currentItem, inClass)
        })
    },

    clearTransStyle: function (item, classToRemove) {
      var base = this
      item.css({
        'position': '',
        'left': ''
      }).removeClass(classToRemove)

      if (base.endPrev && base.endCurrent) {
        base.$owlWrapper.removeClass('owl-origin')
        base.endPrev = false
        base.endCurrent = false
        base.isTransition = false
      }
    },

    owlStatus: function () {
      var base = this
      base.owl = {
        'userOptions': base.userOptions,
        'baseElement': base.$elem,
        'userItems': base.$userItems,
        'owlItems': base.$owlItems,
        'currentItem': base.currentItem,
        'prevItem': base.prevItem,
        'visibleItems': base.visibleItems,
        'isTouch': base.browser.isTouch,
        'browser': base.browser,
        'dragDirection': base.dragDirection
      }
    },

    clearEvents: function () {
      var base = this
      base.$elem.off('.owl owl mousedown.disableTextSelect')
      $(document).off('.owl owl')
      $(window).off('resize', base.resizer)
    },

    unWrap: function () {
      var base = this
      if (base.$elem.children().length !== 0) {
        base.$owlWrapper.unwrap()
        base.$userItems.unwrap().unwrap()
        if (base.owlControls) {
          base.owlControls.remove()
        }
      }
      base.clearEvents()
      base.$elem.attr({
        style: base.$elem.data('owl-originalStyles') || '',
        class: base.$elem.data('owl-originalClasses')
      })
    },

    destroy: function () {
      var base = this
      base.stop()
      window.clearInterval(base.checkVisible)
      base.unWrap()
      base.$elem.removeData()
    },

    reinit: function (newOptions) {
      var base = this,
        options = $.extend({}, base.userOptions, newOptions)
      base.unWrap()
      base.init(options, base.$elem)
    },

    addItem: function (htmlString, targetPosition) {
      var base = this,
        position

      if (!htmlString) {
        return false
      }

      if (base.$elem.children().length === 0) {
        base.$elem.append(htmlString)
        base.setVars()
        return false
      }
      base.unWrap()
      if (targetPosition === undefined || targetPosition === -1) {
        position = -1
      } else {
        position = targetPosition
      }
      if (position >= base.$userItems.length || position === -1) {
        base.$userItems.eq(-1).after(htmlString)
      } else {
        base.$userItems.eq(position).before(htmlString)
      }

      base.setVars()
    },

    removeItem: function (targetPosition) {
      var base = this,
        position

      if (base.$elem.children().length === 0) {
        return false
      }
      if (targetPosition === undefined || targetPosition === -1) {
        position = -1
      } else {
        position = targetPosition
      }

      base.unWrap()
      base.$userItems.eq(position).remove()
      base.setVars()
    }

  }

  $.fn.owlCarousel = function (options) {
    return this.each(function () {
      if ($(this).data('owl-init') === true) {
        return false
      }
      $(this).data('owl-init', true)
      var carousel = Object.create(Carousel)
      carousel.init(options, this)
      $.data(this, 'owlCarousel', carousel)
    })
  }

  $.fn.owlCarousel.options = {

    items: 5,
    itemsCustom: false,
    itemsDesktop: [1199, 4],
    itemsDesktopSmall: [979, 3],
    itemsTablet: [768, 2],
    itemsTabletSmall: false,
    itemsMobile: [479, 1],
    singleItem: false,
    itemsScaleUp: false,

    slideSpeed: 200,
    paginationSpeed: 800,
    rewindSpeed: 1000,

    autoPlay: true,
    stopOnHover: true,

    navigation: false,
    navigationText: ['prev', 'next'],
    rewindNav: true,
    scrollPerPage: false,

    pagination: true,
    paginationNumbers: true,

    responsive: true,
    responsiveRefreshRate: 200,
    responsiveBaseWidth: window,

    baseClass: 'owl-carousel',
    theme: 'owl-theme',

    lazyLoad: false,
    lazyFollow: true,
    lazyEffect: 'fade',

    autoHeight: true,

    jsonPath: false,
    jsonSuccess: false,

    dragBeforeAnimFinish: true,
    mouseDrag: true,
    touchDrag: true,

    addClassActive: false,
    transitionStyle: false,

    beforeUpdate: false,
    afterUpdate: false,
    beforeInit: false,
    afterInit: false,
    beforeMove: false,
    afterMove: false,
    afterAction: false,
    startDragging: false,
    afterLazyLoad: false
  }
}
export {
  carouse
}
